package collection;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

/**
 * Collection是父接口,list和set子接口,arraylist都为实现类
 * List集合特点: 1.有序的集合,2.允许存储重复的元素
 */
public class ListDemo {
    /**
     * ArrayList(实现动态数组)，查询快，增删慢。非线程安全。数组长度是可变的百分之五十延长
     * LinkedList（实现链表），查询慢，增删快,非线程安全。
     * Vector（实现动态数组），都慢，被ArrayList替代。长度任意延长。线程安全（同步的类，函数都是synchronized）
     * Stack（实现栈结构）继承于Vector，先进后出。
     *
     * List 集合可以存储null，添加几个，存储几个；
     */
    public static void main(String[] args) {

        /*
         * 插入：add()
         * 插入全部: addAll(Collection c)      //将c中的每一个元素添加到集合中
         * 查找：get()
         * 删除：remove(int index)
         * 删除全部: removeAll(Collection c); //删除交集
         * 修改：set()
         * 长度: size()
         * 清空表：clear()
         * 包含: containsAll(Collection c)   //判断集合中是否包含传入集合的内容
         * 取交集: retainAll(Collection c)   //取交集(保留交集)
         * 遍历：用Iterator迭代器遍历每个元素
         */
        testArrayBaseList();
        testArrayList();
        testLinkedList();
        testIterator();
    }

    /**
     * 存储基本数据类型
     */
    private static void testArrayBaseList() {
        /*
         * 向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。
         * 基本类型    包装类（引用类型，包装类都位于java.lang包下）
         *   byte-Byte
         *   short-Short
         *   int-Integer
         *   long-Long
         *   float-Float
         *   double-Double
         *   char-Character
         *   boolean-Boolean
         */
        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(100);
        listC.add(200);
        System.out.println(listC); // [100, 200]

        int num = listC.get(1);
        System.out.println("第1号元素是：" + num);
    }


    /**
     * 测试ArrayList函数
     */
    private static void testArrayList() {
        ArrayList<String> list = new ArrayList<>();
        int maxTestCount = 50000;

        //测试添加
        long start = System.currentTimeMillis();
        for (int i = 0; i < maxTestCount; i++) {
            list.add(0, String.valueOf(i));
        }
        long end = System.currentTimeMillis();
        System.out.println("ArrayList 添加 cost time :" + (end - start));

        //测试查询
        start = System.currentTimeMillis();
        for (int i = 0; i < maxTestCount; i++) {
            list.get(i);
        }
        end = System.currentTimeMillis();
        System.out.println("ArrayList 查询 cost time :" + (end - start));

        //测试删除
        start = System.currentTimeMillis();
        for (int i = maxTestCount; i > 0; i--) {
            list.remove(0);
        }
        end = System.currentTimeMillis();
        System.out.println("ArrayList 删除 cost time :" + (end - start));

    }

    /**
     * 测试LinkedList函数
     */
    private static void testLinkedList() {
        LinkedList<String> list = new LinkedList<>();
        int maxTestCount = 50000;
        /*
        注意:使用LinkedList集合特有的方法:(不能使用多态)
        - public void addFirst(E e):将指定元素插入此列表的开头。
        - public void push(E e):将元素推入此列表所表示的堆栈(等效于addFirst)。
        - public void addLast(E e):将指定元素添加到此列表的结尾。

        - public E getFirst():返回此列表的第一个元素。
        - public E getLast():返回此列表的最后一个元素。

        - public E removeFirst():移除并返回此列表的第一个元素。
        - public E removeLast():移除并返回此列表的最后一个元素。
        - public E pop():从此列表所表示的堆栈处弹出一个元素(相当于 removeFirst)。

        - public boolean isEmpty()：如果列表不包含元素，则返回true。
         */

        //测试添加
        long start = System.currentTimeMillis();
        for (int i = 0; i < maxTestCount; i++) {
            list.add(0, String.valueOf(i));
        }
        long end = System.currentTimeMillis();
        System.out.println("LinkedList 添加 cost time :" + (end - start));

        //测试查询
        start = System.currentTimeMillis();
        for (int i = 0; i < maxTestCount; i++) {
            list.get(i);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList 查询 cost time :" + (end - start));


        //测试删除
        start = System.currentTimeMillis();
        for (int i = maxTestCount; i > 0; i--) {
            list.remove(0);
        }
        end = System.currentTimeMillis();
        System.out.println("LinkedList 删除 cost time :" + (end - start));


    }

    /**
     * 迭代器使用
     */
    private static void testIterator() {
        List list = new ArrayList();
        list.add("a");                                    //Object obj = new String();
        list.add("b");
        list.add("world");
        list.add("c");
        list.add("d");
        list.add("e");

		/*Iterator it = list.iterator();					//获取迭代器
		while(it.hasNext()) {							//判断集合中是否有元素
			String str = (String)it.next();				//向下转型,获取数据
			if("world".equals(str)) {
				list.add("javaee");						//遍历的同时在增加元素,并发修改ConcurrentModificationException
			}
		}*/

        ListIterator lit = list.listIterator();    //获取带集合的迭代器(List集合特有的)
        while (lit.hasNext()) {
            String str = (String) lit.next();    //向下转型
            if ("world".equals(str)) {
                //list.add("javaee");			//遍历的同时在增加元素并发修改ConcurrentModificationException
                lit.add("javaee");
            }
        }

        System.out.println(list);
    }
}
